Come posso rimuovere un elemento specifico da un array?

1
2
3
4
Il prossimo
Trova l'indice dell'elemento dell'array che desideri rimuovere usando indexOf, quindi rimuovi quell'indice con splice.
Il metodo splice () modifica il contenuto di un array rimuovendo
elementi esistenti e / o aggiunta di nuovi elementi.
matrice const = [2, 5, 9];
console.log (array);
indice const = array.indexOf (5);
if (indice> -1) {
array.splice (index, 1);
}
// array = [2, 9]
console.log (array);
Il secondo parametro di giunzione è il numero di elementi da rimuovere. Notare che splice modifica la matrice in posizione e restituisce una nuova matrice contenente gli elementi che sono stati rimossi.
Per ragioni di completezza, ecco le funzioni. La prima funzione rimuove solo una singola occorrenza (cioè rimuove la prima corrispondenza di 5 da [2,5,9,1,5,8,5]), mentre la seconda funzione rimuove tutte le occorrenze:
function removeItemOnce (arr, value) {
var index = arr.indexOf (valore);
if (indice> -1) {
arr.splice (indice, 1);
}
return arr;
}
function removeItemAll (arr, value) {
var i = 0;
while (i  = 0; i--) {
if (array [i] === numero) {
array.splice (i, 1);
}
}
Se vuoi solo fare in modo che l'elemento all'indice i non esista più, ma non vuoi che gli indici degli altri elementi cambino:
elimina array [i];
|
Modificato nell'ottobre 2016
Fallo semplice, intuitivo ed esplicito (il rasoio di Occam)
Fallo immutabile (l'array originale rimane invariato)
Fallo con le funzioni JavaScript standard, se il tuo browser non le supporta, usa polyfill
In questo esempio di codice utilizzo la funzione "array.filter (...)" per rimuovere elementi indesiderati da un array. Questa funzione non modifica l'array originale e ne crea uno nuovo. Se il tuo browser non supporta questa funzione (ad esempio Internet Explorer prima della versione 9 o Firefox prima della versione 1.5), considera l'utilizzo del filtro polyfill di Mozilla.
Rimozione dell'elemento (codice ECMA-262 Edizione 5 noto anche come JavaScript vecchio stile)
valore var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (function (item) {
articolo di ritorno! == valore
})
console.log (arr)
// [1, 2, 4, 5]
Rimozione di un elemento (codice ECMAScript 6)
sia valore = 3
lascia arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
IMPORTANTE La sintassi della funzione freccia ECMAScript 6 "() => {}" non è affatto supportata in Internet Explorer, Chrome prima della versione 45, Firefox prima della versione 22 e Safari prima della versione 10. Per usare la sintassi ECMAScript 6 nei vecchi browser puoi usare BabelJS.
Rimozione di più elementi (codice ECMAScript 7)
Un ulteriore vantaggio di questo metodo è che puoi rimuovere più elementi
let forDeletion = [2, 3, 5]
lascia arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Leggi di seguito sul supporto di array.includes (...) !!!
console.log (arr)
// [1, 4]
IMPORTANTE La funzione "array.includes (...)" non è affatto supportata in Internet Explorer, Chrome prima della versione 47, Firefox prima della versione 43, Safari prima della versione 9 e Edge prima della versione 14, quindi ecco il polyfill di Mozilla.
Rimozione di più elementi (in futuro, forse)
Se la proposta "This-Binding Syntax" viene accettata, sarai in grado di farlo:
// array-lib.js
funzione di esportazione remove (... forDeletion) {
restituisci this.filter (item =>! forDeletion.includes (item))
}
// main.js
importa {remove} da "./array-lib.js"
lascia arr = [1, 2, 3, 4, 5, 3]
// :: Proposta di sintassi vincolante
// utilizzo della funzione "rimuovi" come "metodo virtuale"
// senza estendere Array.prototype
arr = arr :: elimina (2, 3, 5)
console.log (arr)
// [1, 4]
Provalo tu stesso su BabelJS :)
Riferimento
Array.prototype.includes
Composizione funzionale
|
Dipende se vuoi mantenere un posto vuoto o meno.
Se vuoi uno slot vuoto:
array [index] = undefined;
Se non vuoi uno slot vuoto:
// Per mantenere l'originale:
// oldArray = [... array];
// Questo modifica l'array.
array.splice (index, 1);
E se hai bisogno del valore di quell'elemento, puoi semplicemente memorizzare l'elemento dell'array restituito:
valore var = array.splice (index, 1) [0];
Se vuoi rimuovere una delle estremità dell'array, puoi usare array.pop () per l'ultimo o array.shift () per il primo (entrambi restituiscono anche il valore dell'elemento).
Se non conosci l'indice dell'elemento, puoi usare array.indexOf (item) per ottenerlo (in if () per ottenere un elemento o in un istante () per ottenerli tutti). array.indexOf (item) restituisce l'indice o -1 se non trovato.
|
Un amico stava riscontrando problemi con Internet Explorer 8 e mi ha mostrato cosa faceva. Gli ho detto che era sbagliato e lui mi ha detto che aveva la rispostaQui. L'attuale risposta principale non funzionerà in tutti i browser (Internet Explorer 8 ad esempio) e rimuoverà solo la prima occorrenza dell'elemento.
Rimuovi TUTTE le istanze da un array
funzione array_remove_index_by_value (arr, item)
{
for (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Passa attraverso l'array all'indietro (poiché gli indici e la lunghezza cambieranno quando gli elementi vengono rimossi) e rimuove l'elemento se viene trovato. Funziona in tutti i browser.
|
Esistono due approcci principali:
splice (): anArray.splice (index, 1);
delete: elimina anArray [index];
Fai attenzione quando usi delete per un array. È utile per eliminare gli attributi degli oggetti, ma non così buono per gli array. È meglio usare la giunzione per gli array.
Tieni presente che quando usi delete per un array potresti ottenere risultati errati per anArray.length. In altre parole, l'eliminazione rimuove l'elemento, ma non aggiorna il valore della proprietà length.
Puoi anche aspettarti di avere buchi nei numeri di indice dopo aver usato delete, ad es. potresti finire con gli indici 1, 3, 4, 8, 9 e 11 e la lunghezza com'era prima di usare Elimina. In tal caso, tutti i cicli indicizzati per andrebbero in crash, poiché gli indici non sono più sequenziali.
Se sei costretto a usare delete per qualche motivo, dovresti usare per ogni loop quando hai bisogno di scorrere gli array. In effetti, evita sempre di utilizzare i cicli indicizzati for, se possibile. In questo modo il codice sarebbe più robusto e meno soggetto a problemi con gli indici.
|
Array.prototype.remove_by_value = function (val) {
for (var i = 0; i  row.id === 5);
var removed = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definizione
var helper = {
// Rimuove e restituisce la prima occorrenza
removeOne: function (array, predicate) {
for (var i = 0; i  [2, 3, 4]
|
Puoi usare ES6. Ad esempio, per eliminare il valore "3" in questo caso:
var array = ["1", "2", "3", "4", "5", "6"]
var newArray = array.filter ((value) => value! = '3');
console.log (newArray);
Produzione :
["1", "2", "4", "5", "6"]
|
Se desideri rimuovere un nuovo array con le posizioni eliminate, puoi sempre eliminare l'elemento specifico e filtrare l'array. Potrebbe essere necessaria un'estensione dell'oggetto array per i browser che non implementano il metodo di filtro, ma a lungo termine è più semplice poiché tutto ciò che fai è questo:
var my_array = [1, 2, 3, 4, 5, 6];
elimina my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Dovrebbe visualizzare [1, 2, 3, 4, 6].
|
Ecco alcuni modi per rimuovere un elemento da un array utilizzando JavaScript.
Tutti i metodi descritti non mutano l'array originale, ma ne creano uno nuovo.
Se conosci l'indice di un articolo
Supponiamo di avere un array e di voler rimuovere un elemento nella posizione i.
Un metodo consiste nell'usare slice ():
elementi cost = ["a", "b", "c", "d", "e", "f"]
const i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () crea un nuovo array con gli indici che riceve. Creiamo semplicemente un nuovo array, dall'inizio all'indice che vogliamo rimuovere, e concateniamo un altro array dalla prima posizione successiva a quello rimosso alla fine dell'array.
Se conosci il valore
In questo caso, una buona opzione è usare filter (), che offre un approccio più dichiarativo:
elementi cost = ["a", "b", "c", "d", "e", "f"]
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Questo utilizza le funzioni freccia ES6. È possibile utilizzare le funzioni tradizionali per supportare i browser meno recenti:
elementi cost = ["a", "b", "c", "d", "e", "f"]
const valueToRemove = 'c'
const filteredItems = items.filter (function (item) {
articolo di ritorno! == valueToRemove
})
console.log (filteredItems)
oppure puoi usare Babel e trasferire il codice ES6 di nuovo in ES5 per renderlo più digeribile ai vecchi browser, ma scrivere JavaScript moderno nel tuo codice.
Rimozione di più elementi
E se invece di un singolo elemento, desideri rimuovere molti elementi?
Troviamo la soluzione più semplice.
Per indice
Puoi semplicemente creare una funzione e rimuovere gli elementi in serie:
elementi cost = ["a", "b", "c", "d", "e", "f"]
const removeItem = (elementi, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filteredItems = removeItem (elementi, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Per valore
Puoi cercare l'inclusione all'interno della funzione di callback:
elementi cost = ["a", "b", "c", "d", "e", "f"]
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Evita di modificare l'array originale
splice () (da non confondere con slice ()) modifica l'array originale e dovrebbe essere evitato.
(originariamente pubblicato sul mio sito https://flaviocopes.com/how-to-remove-item-from-array/)
|
Controlla questo codice. Funziona in tutti i principali browser.
remove_item = function (arr, value) {
var b = '';
for (b in arr) {
if (arr [b] === value) {
arr.splice (b, 1);
rompere;
}
}
return arr;
};
Chiama questa funzione
remove_item (array, valore);
|
ES6 e senza mutazione: (ottobre 2016)
const removeByIndex = (list, index) =>
[
... list.slice (0, index),
... list.slice (indice + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (output)
|
Puoi usare lodash _.pull (mutate array), _.pullAt (mutate array) o _.without (non muta array)
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
La rimozione di un particolare elemento / stringa da un array può essere eseguita in una riga:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
dove:
theArray: l'array da cui vuoi rimuovere qualcosa di particolare
stringToRemoveFromArray: la stringa che vuoi rimuovere e 1 è la quantità di elementi che vuoi rimuovere.
NOTA: Se "stringToRemoveFromArray" non si trova nell'array, questo rimuoverà l'ultimo elemento dell'array.
È sempre buona norma verificare prima se l'elemento esiste nell'array, prima di rimuoverlo.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Se hai accesso a versioni più recenti di Ecmascript sui computer del tuo client (ATTENZIONE, potrebbe non funzionare su stazioni meno recenti):
var array = ["1", "2", "3", "4", "5", "6"]
var newArray = array.filter ((value) => value! = '3');
Dove "3" è il valore che vuoi rimuovere dall'array.
L'array diventerebbe quindi: ['1', '2', '4', '5', '6']
|
OK, ad esempio hai l'array qui sotto:
var num = [1, 2, 3, 4, 5];
E vogliamo eliminare il numero 4. Puoi semplicemente usare il codice seguente:
num.splice (num.indexOf (4), 1); // num sarà [1, 2, 3, 5];
Se stai riutilizzando questa funzione, scrivi una funzione riutilizzabile che verrà allegata alla funzione array nativa come di seguito:
Array.prototype.remove = Array.prototype.remove || funzione (x) {
const i = this.indexOf (x);
se (i === - 1)
ritorno;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Ma che ne dici se hai l'array di seguito invece con alcuni [5] s nell'array?
var num = [5, 6, 5, 4, 5, 1, 5];
Abbiamo bisogno di un ciclo per controllarli tutti, ma un modo più semplice ed efficiente è utilizzare le funzioni JavaScript incorporate, quindi scriviamo una funzione che utilizza un filtro come di seguito:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Inoltre ci sono librerie di terze parti che ti aiutano a farlo, come Lodash o Underscore. Per ulteriori informazioni, guarda lodash _.pull, _.pullAt o _.without.
|
Prestazione
Oggi (2019-12-09) conduco test delle prestazioni su macOS v10.13.6 (High Sierra) per le soluzioni scelte. Mostro delete (A), ma non lo uso in confronto ad altri metodi, perché ha lasciato spazio vuoto nell'array.
Le conclusioni
la soluzione più veloce è array.splice (C) (tranne Safari per i piccoli array in cui ha la seconda volta)
per i big array, array.slice + splice (H) è la soluzione immutabile più veloce per Firefox e Safari; Array.from (B) è il più veloce in Chrome
le soluzioni mutabili sono solitamente 1,5x-6 volte più veloci di quelle immutabili
per i tavolini su Safari, sorprendentemente la soluzione mutabile (C) è più lenta della soluzione immutabile (G)
Dettagli
Nei test rimuovo l'elemento centrale dall'array in modi diversi. Le soluzioni A, C sono sul posto. Le soluzioni B, D, E, F, G, H sono immutabili.
Risultati per array con 10 elementi
In Chrome, array.splice (C) è la soluzione sul posto più veloce. Array.filter (D) è la soluzione immutabile più veloce. Il più lento è array.slice (F). Puoi eseguire il test sulla tua macchina qui.
Risultati per array con 1.000.000 di elementi
In Chrome array.splice (C) è la soluzione sul posto più veloce (l'eliminazione (C) è simile veloce, ma ha lasciato uno slot vuoto nell'array (quindi non esegue una "rimozione completa")). Array.slice-splice (H) è la soluzione immutabile più veloce. Il più lento è array.filter (D ed E). Puoi eseguire il test sulla tua macchina qui.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
funzione A (array) {
var index = array.indexOf (5);
elimina array [indice];
log ('A', array);
}
funzione B (array) {
var index = array.indexOf (5);
var arr = Array.from (array);
arr.splice (indice, 1)
log ("B", arr);
}
funzione C (array) {
var index = array.indexOf (5);
array.splice (index, 1);
log ('C', array);
}
funzione D (array) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
funzione E (array) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
funzione F (array) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ("F", arr);
}
funzione G (array) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
funzione H (array) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (indice, 1);
log ("H", arr);
}
Aa]);
B ([... a]);
Circa]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
H ([... a]);
Questo frammento presenta solo il codice utilizzato nei test delle prestazioni, non esegue i test da solo.
Confronto per i browser: Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0
|
Sono abbastanza nuovo in JavaScript e avevo bisogno di questa funzionalità. Ho semplicemente scritto questo:
function removeFromArray (array, item, index) {
while ((index = array.indexOf (item))> -1) {
array.splice (index, 1);
}
}
Quindi quando voglio usarlo:
// Imposta alcuni dati fittizi
var dummyObj = {nome: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Rimuove i dati fittizi
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Risultato: come previsto.
["elemento1", "elemento1"]
Potresti avere esigenze diverse dalle mie, quindi puoi modificarle facilmenteper adattarsi a loro. Spero che questo aiuti qualcuno.
|
Se hai oggetti complessi nell'array puoi usare i filtri?
In situazioni in cui $ .inArray o array.splice non è così facile da usare. Soprattutto se gli oggetti sono forse poco profondi nell'array.
Per esempio. se hai un oggetto con un campo Id e vuoi che l'oggetto venga rimosso da un array:
this.array = this.array.filter (function (element, i) {
return element.id! == idToRemove;
});
|
Voglio rispondere in base a ECMAScript 6. Supponi di avere un array come di seguito:
sia arr = [1,2,3,4];
Se vuoi eliminare in un indice speciale come 2, scrivi il codice seguente:
arr.splice (2, 1); // => arr è diventato [1,2,4]
Ma se vuoi eliminare un elemento speciale come 3 e non conosci il suo indice, fai come di seguito:
arr = arr.filter (e => e! == 3); // => arr è diventato [1,2,4]
Suggerimento: utilizza una funzione freccia per richiamare il filtro a meno che non otterrai un array vuoto.
|
Aggiornamento: questo metodo è consigliato solo se non è possibile utilizzare ECMAScript 2015 (precedentemente noto come ES6). Se puoi usarlo, altre risposte qui forniscono implementazioni molto più ordinate.
Questa sintesi qui risolverà il tuo problema e cancellerà anche tutte le occorrenze dell'argomento anziché solo 1 (o un valore specificato).
Array.prototype.destroy = function (obj) {
// Restituisce null se non sono stati trovati e rimossi oggetti
var distrutto = null;
for (var i = 0; i  3
x.destroy (falso); // => false
X; // => [1, 2, true, undefined]
x.destroy (vero); // => vero
x.destroy (undefined); // => undefined
X; // => [1, 2]
x.destroy (3); // => null
X; // => [1, 2]
|
Aggiornamento ES10
Questo post riassume gli approcci comuni alla rimozione degli elementi dall'array a partire da ECMAScript 2019 (ES10).
1. Casi generali
1.1. Rimozione dell'elemento Array in base al valore utilizzando .splice ()
| Sul posto: Sì |
| Rimuove i duplicati: Sì (loop), No (indexOf) |
| Per valore / indice: Per indice |
Se conosci il valore che desideri rimuovere da un array, puoi utilizzare il metodo splice. Per prima cosa devi identificare l'indice dell'elemento di destinazione. Quindi si utilizza l'indice come elemento iniziale e si rimuove solo un elemento.
// Con un ciclo "for"
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (sia i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Con il metodo .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Rimozione dell'elemento Array utilizzando il metodo .filter ()
| Sul posto: No |
| Rimuove i duplicati: Sì |
| Per valore / indice: Per valore |
L'elemento specifico può essere filtrato dall'array, fornendo la funzione di filtro. Tale funzione viene quindi chiamata per ogni elemento dell'array.
valore const = 3
lascia arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
1.3. Rimozione dell'elemento Array estendendo Array.prototype
| Sul posto: Sì / No (dipende dall'implementazione) |
| Rimuove i duplicati: Sì / No (dipende dall'implementazione) |
| Per valore / indice: per indice / per valore (dipende dall'implementazione) |
Il prototipo di array può essere esteso con metodi aggiuntivi. Tali metodi saranno quindi disponibili per essere utilizzati sugli array creati.
Nota: l'estensione di prototipi di oggetti dalla libreria standard di JavaScript (come Array) è considerata da alcuni come un antipattern.
// Sul posto, rimuove tutto, in base all'implementazione del valore
Array.prototype.remove = function (item) {
for (let i = 0; i  = ES10)
| Sul posto: No |
| Rimuove i duplicati: Sì |
| Per valore / indice: Per valore |
ES10 ha introdotto Object.fromEntries, che può essereutilizzato per creare l'array desiderato da qualsiasi oggetto simile a un array e filtrare gli elementi indesiderati durante il processo.
oggetto const = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (oggetto)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Casi speciali
2.1 Rimuovere l'elemento se si trova alla fine di Array
2.1.1. Modifica della lunghezza dell'array
| Sul posto: Sì |
| Rimuove i duplicati: No |
| Per valore / indice: N / A |
Gli elementi array JavaScript possono essere rimossi dalla fine di un array impostando la proprietà length su un valore inferiore al valore corrente. Qualsiasi elemento il cui indice è maggiore o uguale alla nuova lunghezza verrà rimosso.
const arr = [1, 2, 3, 4, 5, 6];
lunghezza arr. = 5; // Imposta la lunghezza per rimuovere l'elemento
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Utilizzando il metodo .pop ()
| Sul posto: Sì |
| Rimuove i duplicati: No |
| Per valore / indice: N / A |
Il metodo pop rimuove l'ultimo elemento dell'array, restituisce quell'elemento e aggiorna la proprietà length. Il metodo pop modifica l'array su cui viene invocato, ciò significa che a differenza dell'uso di delete l'ultimo elemento viene rimosso completamente e la lunghezza dell'array ridotta.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // restituisce 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Rimozione dell'elemento se si trova all'inizio di Array
| Sul posto: Sì |
| Rimuove i duplicati: No |
| Per valore / indice: N / A |
Il metodo .shift () funziona in modo molto simile al metodo pop tranne che rimuove il primo elemento di un array JavaScript invece dell'ultimo. Quando l'elemento viene rimosso, gli elementi rimanenti vengono spostati verso il basso.
const arr = [1, 2, 3, 4];
arr.shift (); // restituisce 1
console.log (arr); // [2, 3, 4]
2.3. Rimozione di un elemento se è l'unico elemento in Array
| Sul posto: Sì |
| Rimuove i duplicati: N / A |
| Per valore / indice: N / A |
La tecnica più veloce consiste nell'impostare una variabile di matrice su una matrice vuota.
let arr = [1];
arr = []; // array vuoto
In alternativa, è possibile utilizzare la tecnica da 2.1.1 impostando la lunghezza su 0.
|
Non dovresti mai modificare il tuo array. Poiché questo è contro il modello di programmazione funzionale. È possibile creare un nuovo array senza fare riferimento all'array di cui si desidera modificare i dati utilizzando il filtro del metodo ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Supponiamo di voler rimuovere 5 dall'array, puoi semplicemente farlo in questo modo:
myArray = myArray.filter (value => value! == 5);
Questo ti darà un nuovo array senza il valore che vuoi rimuovere. Quindi il risultato sarà:
[1, 2, 3, 4, 6]; // 5 è stato rimosso da questo array
Per ulteriori informazioni puoi leggere la documentazione MDN su Array.filter.
|
Un approccio più moderno, ECMAScript 2015 (precedentemente noto come Harmony o ES 6). Dato:
elementi cost = [1, 2, 3, 4];
indice const = 2;
Poi:
items.filter ((x, i) => i! == index);
Resa:
[1, 2, 4]
Puoi utilizzare Babel e un servizio polyfill per assicurarti che sia ben supportato su tutti i browser.
|
Puoi fare un ciclo all'indietro per assicurarti di non rovinare gli indici, se ci sono più istanze dell'elemento.
var myElement = "cioccolato";
var myArray = ['cioccolato', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
/ * Codice importante * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Dimostrazione dal vivo
|
Hai da 1 a 9 nell'array e vuoi rimuoverlo 5. Usa il codice seguente:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return m! == 5;
});
console.log ("new Array, 5 removed", newNumberArray);
Se vuoi più valori. Esempio: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
ritorno (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("new Array, 1,7 e 8 removed", newNumberArray);
Se vuoi rimuovere un valore di array in un array. Esempio: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("new Array, [3,4,5] removed", newNumberArray);
Include il browser supportato è il collegamento.
|
1
2
3
4
Il prossimo
Domanda molto attiva. Guadagna 10 punti reputazione per rispondere a questa domanda. Il requisito di reputazione aiuta a proteggere questa domanda dallo spam e dalle attività di mancata risposta.
Non è la risposta che stai cercando? Sfoglia altre domande contrassegnate come array javascript o fai la tua domanda.